/**
 * 书籍操作方法库
 */

// 引用App方法
const app = getApp();
const BaseURL = app.globalData.baseURL;

/**
 * 显示书籍信息
 * @param { Object } api 操作书籍信息的API接口的文件名称配置
 */
function pageOption(api) {
    return {
        /**
         * 页面的初始数据
         */
        data: {
            // 书籍列表
            bookList: [],
            bookCount: 0,
            hasBook: false,
            // 书籍表单添加面板——显示状态
            bookinfoAddPannel_show: false,
            // 表单输入的值
            bookInfo: {
                book_ID: '000',
                bookName: '',
                bookName_sub: '',
                bookAuthor: '',
                publisher: '',
                noteList: '[]'
            },
            // 表单输入验证成功图标状态
            successState: {
                bookName: false,
                bookName_sub: false,
                bookAuthor: false,
                publisher: false
            },
            // 按钮状态
            defaultSize: 'default',
            primarySize: 'default',
            disabled: false,
            dialogInfoShow: false,
            // 书籍信息表单处于新增状态（新增 || 修改）
            bookInfo_isAdd: true,
            // 对话框信息
            dialogInfo: {
                bookName: '',
                bookSubName: '',
                bookAuthor: '',
                publisher: '',
                startReadDate: '',
                noteCount: ''
            }

        },
    
        /**
         * 生命周期函数--监听页面加载
         */
        onLoad: function (options) {
            // 调用加载书籍数据功能
            this.loadBookData();
        },
    
        /**
         * 加载书籍数据功能
         */
        loadBookData() {
            const _this = this;
            // 请求“成长类”书籍的AJAX配置
            wx.request({
                method: 'GET',
                url: `${BaseURL}book_info-get.php`,
                dataType: 'json',
                data: {
                    databaseName: api.databaseName
                },
                header: {
                    'content-type': 'application/json'
                },
                success(res) {
                    // 获取书籍数量
                    const bookCount = res.data.length;
                    _this.setData({
                        // 修改书籍列表的内容
                        bookList: res.data,
                        bookCount: bookCount
                    });

                    setTimeout(function() {
                        // 如果书籍列表有内容存在
                        if (_this.data.bookCount) {
                            _this.setData({
                                // 设置书籍列表显示状态为 true
                                hasBook: true
                            });
                        } else {
                            _this.setData({
                                // 设置书籍列表显示状态为 false
                                hasBook: false
                            });
                        }
                    },100);
                }
            });
        },
    
        /**
         * 跳转到笔记页
         * @param { Object } even 
         */
        toNotesPage(even) {
            // 当前书籍对象
            const theBook = even.currentTarget.dataset.book;
    
            // 设置this
            const _this = this;
    
            // 执行跳转
            wx.navigateTo({
                url: '/pages/notes/notes',
                events: {
                    // 为指定事件添加一个监听器，获取被打开页面传送到当前页面的数据
                    acceptDataFromOpenedPage: function (data) {
                        // 将被打开的页传递过来的数据对 bookInfo 进行更新
                        _this.setData({
                            bookList: data
                        });
                    }
                },
                success: function (res) {
                    // 传送数据书籍信息到目标页面
                    res.eventChannel.emit('getTheBookInfo', theBook);
                    // 传送接口文件名称到目标页面
                    res.eventChannel.emit('getApiFile', {
                        noteAdd: 'book_note-operate.php',
                        getInfo: 'book_info-get.php',
                        databaseName: api.databaseName
                    });
                }
            });
        },
    
        /**
         * 显示书籍信息
         * @param { Object } even 当前书籍事件对象
         */
        showBookInfo(even) {
            // 获取当前书籍对象信息
            const bookInfo = even.currentTarget.dataset.item;
            const notes_str = bookInfo.noteList.replace(/\n+/gm, '\\n')
                              .replace(/\r+/gm, '\\r');

            // 获取笔记列表及其数量
            const notes = typeof(notes_str) === "string" ? JSON.parse(notes_str) : notes_str;
 
            const noteCount = notes.length;
    
            this.setData({
                dialogInfo: {
                    bookName: bookInfo.bookName,
                    bookSubName: bookInfo.bookName_sub,
                    bookAuthor: bookInfo.bookAuthor,
                    publisher: bookInfo.publisher,
                    startReadDate: bookInfo.startReadDate,
                    noteCount: `当前书籍含有 ${noteCount} 条笔记`
                },
                dialogInfoShow: true
            });
        },
    
        /**
         * 编辑书籍信息
         * @param { Object } book 当前书籍信息
         */
        editBookInfo(book) {
            // 获取当前书籍详情信息
            const theBookInfo = book.currentTarget.dataset.item;
            
            this.setData({
                // 显示新增书籍信息的表单面板
                bookinfoAddPannel_show: true,
                // 将表单按钮的状态设置为“修改书籍”
                bookInfo_isAdd: false,
                bookInfo: {
                    book_ID: theBookInfo.book_ID,
                    bookName: theBookInfo.bookName,
                    bookName_sub: theBookInfo.bookName_sub,
                    bookAuthor: theBookInfo.bookAuthor,
                    publisher: theBookInfo.publisher
                }
            });
            // 短暂延迟后设置表单图标状态
            setTimeout(() => {
                this.setData({
                    // 表单输入验证成功图标状态
                    successState: {
                        bookName: this.data.bookInfo.bookName !== "" ? true : false,
                        bookName_sub: this.data.bookInfo.bookName_sub !== "" ? true : false,
                        bookAuthor: this.data.bookInfo.bookAuthor !== "" ? true : false,
                        publisher: this.data.bookInfo.publisher !== "" ? true : false
                    }
                });
            },10);
        },

        /**
         * 保存修改后的书籍信息
         * @param {*} book 
         */
        saveBookInfo() {
            // 创建一个临时克隆书籍信息的对象
            const tempData = Object.assign({}, this.data.bookInfo);
            // 获取 this
            const _this = this;

            // 调用表单输入非空的验证方法，如果返回的是 false，则中断当前操作
            if(!this.noEmptyValid(tempData)) {
                return false;
            }

            // 指定数据库名称
            tempData.databaseName = api.databaseName;

            // 调用修改数据接口
            wx.request({
                method: 'POST',
                url: `${BaseURL}book_info-update.php`,
                dataType: 'text',
                data: tempData,
                header: {
                    'content-type': 'application/x-www-form-urlencoded'
                },
                success(res) {
                    // 调用加载书籍数据功能
                    _this.loadBookData();
    
                    // 显示返回信息
                    wx.showToast({
                        title: res.data,
                        icon: 'success',
                        duration: 2500
                    });
    
                    // 还原表单默认值
                    _this.setData({
                        bookInfo: {
                            book_ID: '000',
                            bookName: '',
                            bookName_sub: '',
                            bookAuthor: '',
                            publisher: ''
                        }
                    });
                }
            });
            
            this.setData({
                // 隐藏表单面板
                bookinfoAddPannel_show: false,
                // 重置表单输入状态图标
                successState: {
                    bookName: false,
                    bookName_sub: false,
                    bookAuthor: false,
                    publisher: false
                }
            });
        },
    
        /**
         * 移除书籍信息
         * @param {*} book 当前书籍事件对象
         */
        removeBookInfo(book) {
            // 获取 this
            const _this = this;

            // 获取当前书籍的ID值
            const bookID = book.currentTarget.dataset.item.book_ID;

            // 弹出确认对话框
            wx.showModal({
                content: '您确定要删除该书籍吗？',
                confirmColor: '#9c1308',
                success (res) {
                    // 确认删除操作
                    if (res.confirm) {
                        // 请求“移除书籍”接口的AJAX配置
                        wx.request({
                            method: 'GET',
                            url: `${BaseURL}book_info-del.php`,
                            dataType: 'text',
                            data: {
                                bookID: bookID,
                                databaseName: api.databaseName
                            },
                            header: {
                                'content-type': 'application/json'
                            },
                            success(res) {
                                wx.showToast({
                                    title: res.data,
                                    icon: 'success',
                                    duration: 2500
                                });
                                // 从新加载数据
                                _this.loadBookData();
                            },
                            fail(error) {
                                wx.showToast({
                                    title: '书籍删除失败！',
                                    icon: 'warn',
                                    duration: 2500
                                });
                                console.error(error);
                            }
                        });
                    } 
                    // 取消删除操作
                    else if (res.cancel) {
                        // 暂时什么都不做
                    }
                }
            });
        },
    
        /**
         * 关闭书籍信息对话框组件方法
         */
        hideDialog() {
            this.setData({
                dialogInfoShow: false
            });
        },
    
        /**
         * 显示书籍添加面板
         */
        showAddpannel() {
            this.setData({
                // 显示新增书籍信息的表单面板
                bookinfoAddPannel_show: true,
                // 将表单按钮的状态设置为“添加书籍”
                bookInfo_isAdd: true
            });
        },
        /**
         * 隐藏书籍添加面板（取消按钮）
         */
        hideAddpannel() {
            this.setData({
                // 隐藏表单面板
                bookinfoAddPannel_show: false,
                // 重置表单数据
                bookInfo: {
                    book_ID: '000',
                    bookName: '',
                    bookName_sub: '',
                    bookAuthor: '',
                    publisher: '',
                    noteList: '[]'
                },
                // 重置表单输入状态图标
                successState: {
                    bookName: false,
                    bookName_sub: false,
                    bookAuthor: false,
                    publisher: false
                }
            });
        },
    
        /**
         * 表单输入数据获取
         * @param { Object } even 
         */
        getInputValue(even) {
            const dataset = even.currentTarget.dataset;

            // 获取当前输入框的 data-name 值
            const dataName = dataset.name;
            // 获取输入的值
            const inputVal = even.detail.value;
    
            // 获取书籍信息对象
            const bookInfo = this.data.bookInfo;
    
            // 创建临时对象获取 bookInfo 的各个属性值
            const tempData = {
                book_ID: bookInfo.book_ID.trim(),
                bookName: bookInfo.bookName.trim(),
                bookName_sub: bookInfo.bookName_sub.trim(),
                bookAuthor: bookInfo.bookAuthor.trim(),
                publisher: bookInfo.publisher.trim(),
                noteList: bookInfo.noteList
            }
            // 为临时对象的属性设置输入的值
            tempData[dataName] = inputVal;

            const noEmptyValid = Object.assign({},this.data.successState);

            // 设置成功状态
            if(tempData[dataName].trim()) {
                noEmptyValid[dataName] = true;
            } else {
                noEmptyValid[dataName] = false;
            }
    
            // 设置表单数据对象
            this.setData({
                bookInfo: tempData,
                successState: noEmptyValid
            });
        },
    
        /**
         * 书籍信息添加
         */
        bookInfoAdd() {
            // 获取当前日期
            const currentDate = this.getStandardDatetime();
    
            // 获取当前表单数据对象
            const tempData = Object.assign({},this.data.bookInfo);
    
            // 添加日期字段
            tempData.startReadDate = currentDate;

            // 指定数据库名称
            tempData.databaseName = api.databaseName;

            // 调用表单输入非空的验证方法，如果返回的是 false，则中断当前操作
            if(!this.noEmptyValid(tempData)) {
                return false;
            }

            const _this = this;
            // 调用添加数据接口
            wx.request({
                method: 'POST',
                url: `${BaseURL}book_info-add.php`,
                dataType: 'text',
                data: tempData,
                header: {
                    'content-type': 'application/x-www-form-urlencoded'
                },
                success(res) {
                    // 调用加载书籍数据功能
                    _this.loadBookData();
    
                    // 显示返回信息
                    wx.showToast({
                        title: res.data,
                        icon: 'success',
                        duration: 2500
                    });
    
                    // 还原表单默认值
                    _this.setData({
                        bookInfo: {
                            book_ID: '000',
                            bookName: '',
                            bookName_sub: '',
                            bookAuthor: '',
                            publisher: '',
                            noteList: '[]'
                        }
                    });
                }
            });
            // 隐藏表单面板
            this.setData({
                // 隐藏表单面板
                bookinfoAddPannel_show: false,
                // 重置表单数据
                bookInfo: {
                    book_ID: '000',
                    bookName: '',
                    bookName_sub: '',
                    bookAuthor: '',
                    publisher: '',
                    noteList: '[]'
                },
                // 重置表单输入状态图标
                successState: {
                    bookName: false,
                    bookName_sub: false,
                    bookAuthor: false,
                    publisher: false
                }
            });
        },

        /**
         * 表单输入非空验证
         * @param { Object } tempData 表单输入的临时对象
         */
        noEmptyValid(tempData) {
            // 数据验证——书籍名
            if(!tempData.bookName.trim()) {
                wx.showToast({
                    title: '书籍名称不能为空',
                    icon: 'none',
                    duration: 2000
                })
                return false;
            }
            // 数据验证——作者名
            if(!tempData.bookAuthor.trim()) {
                wx.showToast({
                    title: '作者名不能为空',
                    icon: 'none',
                    duration: 2000
                })
                return false;
            }
            // 数据验证——作者名
            if(!tempData.publisher.trim()) {
                wx.showToast({
                    title: '出版社必须填写',
                    icon: 'none',
                    duration: 2000
                })
                return false;
            }
            return true;
        },
    
        /**
         * 格式化时间功能
         * @param { Date } datetime 
         */
        getStandardDatetime(datetime) {
            // 格式化时间
            const formatTime = date => {
                const year = date.getFullYear()
                const month = date.getMonth() + 1
                const day = date.getDate()
                const hour = date.getHours()
                const minute = date.getMinutes()
                const second = date.getSeconds()
                return [year, month, day].map(formatNumber).join('/') + ' ' + [hour, minute, second].map(formatNumber).join(':')
            }
    
            // 补零操作
            const formatNumber = n => {
                n = n.toString()
                return n[1] ? n : '0' + n;
            }
    
            // 传入参数并运行
            return datetime ? formatTime(new Date(datetime)) : formatTime(new Date());
        }
    
    }
}

// 暴露方法函数接口
module.exports = {
    pageOption: pageOption
}